ARCHITECTURE MONOLITHIQUE

Définition

L'architecture monolithique est un modèle de conception logicielle où l'ensemble de l'application est construite comme une seule unité indivisible. Tous les composants, services et fonctionnalités sont intégrés dans un seul déploiement.

Cette approche traditionnelle a été largement utilisée dans les premières applications logicielles et reste pertinente pour certains types de projets.

Caractéristiques Principales

Unité indivisible : L'application est déployée comme un tout unique
Couplage fort : Les composants sont étroitement liés entre eux
Structure en couches : Organisation typique en présentation, métier et données
Déploiement unique : Un seul artefact à déployer
Partage de ressources : Tous les composants utilisent les mêmes ressources système

🏠

APPLICATION PRINCIPALE

Point d'entrée unique de l'application. Contient toute la logique métier, les interfaces utilisateur et l'accès aux données dans une seule unité déployable.

Fonction: Exécution complète de l'application

Exemple de Code Spring Boot

@SpringBootApplication

public class MonolithiqueApplication {

  public static void main(String[] args) {

    SpringApplication.run(MonolithiqueApplication.class, args);

  }

}

🖥️

INTERFACE UTILISATEUR

Couche de présentation qui gère l'interaction avec les utilisateurs. Inclut les vues, contrôleurs et modèles pour l'affichage des données.

Fonction: Présentation et interaction utilisateur

Exemple de Contrôleur REST

@RestController

@RequestMapping("/api/users")

public class UserController {

  @Autowired

  private UserService userService;

  @GetMapping("/{id}")

  public User getUser(@PathVariable Long id) {

    return userService.findById(id);

  }

  @PostMapping

  public User createUser(@RequestBody User user) {

    return userService.save(user);

  }

}

⚙️

LOGIQUE MÉTIER

Cœur de l'application contenant les règles de validation, les processus métier et les services applicatifs. Traite les demandes de l'interface utilisateur.

Fonction: Traitement des règles métier

Exemple de Service

@Service

public class UserService {

  @Autowired

  private UserRepository userRepository;

  public User findById(Long id) {

    return userRepository.findById(id)

      .orElseThrow(() -> new UserNotFoundException(id));

  }

  public User save(User user) {

    // Validation des règles métier

    if (user.getEmail() == null || user.getEmail().isEmpty()) {

      throw new IllegalArgumentException("Email requis");

    }

    return userRepository.save(user);

  }

}

💾

ACCÈS AUX DONNÉES

Couche responsable de la communication avec les bases de données et autres systèmes de persistance. Gère les opérations CRUD et les requêtes complexes.

Fonction: Persistance des données

Exemple de Repository JPA

@Repository

public interface UserRepository extends JpaRepository<User, Long> {

  @Query("SELECT u FROM User u WHERE u.email = :email")

  Optional<User> findByEmail(@Param("email") String email);

  @Query("SELECT u FROM User u WHERE u.createdAt > :date")

  List<User> findRecentUsers(@Param("date") LocalDateTime date);

}

🔧

COMPOSANTS COMMUNS

Bibliothèques partagées, utilitaires, services de configuration et modules de sécurité utilisés par l'ensemble de l'application monolithique.

Fonction: Services transversaux

Exemple de Configuration

@Configuration

public class SecurityConfig {

  @Bean

  public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {

    return http

      .authorizeHttpRequests(auth -> auth

        .requestMatchers("/api/public/**").permitAll()

        .anyRequest().authenticated()

      )

      .build();

  }

}

🔌

INTÉGRATIONS EXTERNES

Connecteurs vers des systèmes externes comme les APIs tierces, les services de messagerie ou les systèmes de paiement.

Fonction: Communication externe

Exemple de Client REST

@Service

public class PaymentService {

  @Autowired

  private RestTemplate restTemplate;

  public PaymentResponse processPayment(PaymentRequest request) {

    String url = "https://api.payment.com/process";

    return restTemplate.postForObject(url, request, PaymentResponse.class);

  }

}

Structure d'un Projet Monolithique Spring Boot

com.example.monolithique/

├── MonolithiqueApplication.java

├── controller/

│   ├── UserController.java

│   ├── ProductController.java

│   └── OrderController.java

├── service/

│   ├── UserService.java

│   ├── ProductService.java

│   └── OrderService.java

├── repository/

│   ├── UserRepository.java

│   ├── ProductRepository.java

│   └── OrderRepository.java

├── model/

│   ├── User.java

│   ├── Product.java

│   └── Order.java

├── config/

│   └── DatabaseConfig.java

└── exception/

    └── GlobalExceptionHandler.java

AVANTAGES

Simplicité de développement: Tout le code est dans un seul projet
Déploiement simplifié: Un seul fichier à déployer
Performance: Appels locaux rapides entre composants
Facilité de test: Tests d'intégration plus simples
Gestion unifiée: Une seule base de code à maintenir
Moins de latence: Pas de communication réseau entre composants
Facile à déboguer: Tout est accessible dans un seul environnement

INCONVÉNIENTS

Scalabilité limitée: Impossible de scaler uniquement certaines parties
Difficulté de maintenance: Code complexe au fur et à mesure
Déploiement risqué: Toute modification nécessite un redéploiement complet
Technologie verrouillée: Difficile d'adopter de nouvelles technologies
Temps de démarrage: L'application peut prendre du temps à démarrer
Couplage fort: Modifications risquées entre composants
Difficile à tester: Tests unitaires complexes pour des composants couplés

Cas d'Utilisation

L'architecture monolithique est particulièrement adaptée aux applications simples, aux projets à court terme et aux petites équipes de développement.

Applications avec une logique métier relativement simple
Projets où le temps de mise sur le marché est critique
Petites équipes de développement
Applications legacy existantes
Projets avec un budget limité pour l'infrastructure
Applications internes avec peu d'utilisateurs

CONTRÔLES D'ANIMATION

Afficher/Masquer Labels:

Accélérer:

Ralentir:

Réinitialiser Animation:

Simuler Requête:

Réinitialiser Disposition: